%{
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include "../tableSymbole/hashTable.h"
	#include "tableGencode.h"
	#include "tableValueText.h"
	#include "genMips.h"
	#include "pileStructure.h"
	
	extern FILE* yyin;
	FILE* yyout;
	entree temporaire;
	char * bufferItoA;
	int erreurCompilation;
	int boolTemp;
	int nbSysTemp;
	char * charTemp1;
	char * charTemp2;
	int intTemp1;
	int intTemp2;
%}

%token ENTIER PLUS FOIS PGAUCHE PDROITE IDENTIFIANT POINTVIRGULE AFFECTATION WRITE VAR DEUXPOINTS INT MOINS BOOL STRING NOT OR AND XOR EGAL PPETIT PGRAND PPETITS PGRANDS DIFFERENT BOOLEEN IF THEN ELSE
%start debut
%right AFFECTATION
%left PLUS OR
%left FOIS AND
%left XOR 
%right MOINS NOT 
%left EGAL PPETIT PGRAND PPETITS PGRANDS DIFFERENT
%nonassoc IDENTIFIANT ENTIER BOOL

%%
debut : listdecla  listinstr
	;
listdecla : decla listdecla
	|
	;
decla : VAR IDENTIFIANT DEUXPOINTS type POINTVIRGULE
		{
			if($4 == ENTREE_TYPECTE_ENTIER)
			{
				ajoutEntreeHashTable(nouvelleEntreeCteInt(tableValueText[$2], 0));
			}
			else if($4 = ENTREE_TYPECTE_BOOL)
			{
				ajoutEntreeHashTable(nouvelleEntreeCteBool(tableValueText[$2], FAUX));
			}
			else
			{
				printf("Erreur : Yacc : déclaration de %s : erreur de type.\n",tableValueText[$2]);
				erreurCompilation = 1;
			}
			suppressionTableValueText($2);
		}
	;
type : INT
		{
			$$ = ENTREE_TYPECTE_ENTIER;
		}
	| BOOLEEN
		{
			$$ = ENTREE_TYPECTE_BOOL;
		}
	;
		
listinstr : instr listinstr
	|
	;
instr : IDENTIFIANT AFFECTATION	E POINTVIRGULE
		{			
			if(!existeMotClefHashTableHorsVide(tableValueText[$1]))
			{
				printf("Erreur : Yacc : IDENTIFIANT AFFECTATION	E : identifiant non declare (%s).\n",tableValueText[$1]);
				erreurCompilation = 1;
			}
			else
			{				
				if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
				{
					printf("Erreur : Yacc : IDENTIFIANT AFFECTATION	E : E n'est pas un identifiant.\n");
					erreurCompilation = 1;
				}
				else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != consulteHashTable(tableValueText[$1]).valeur.type)
				{
					printf("Erreur : Yacc : IDENTIFIANT AFFECTATION	E : l'identifiant et E ne sont pas du même type.\n");
					erreurCompilation = 1;
				}
				else
				{
					charTemp1 = ((structureID)(pileStructure[nbPileStructure-1]->valeur))->nom;
					suppressionTetePileStructure();
					printf("\trécupération de %s dans la pileStructure\n",charTemp1);
					
					intTemp1 = ajoutTableGencode("affectation",tableValueText[$1],charTemp1,"");
					printf("\tajout (%d) : %s %s, %s, %s\n",intTemp1, tableGencode[intTemp1]->commande,tableGencode[intTemp1]->adresse1,tableGencode[intTemp1]->adresse2,tableGencode[intTemp1]->adresse3);
				}
			}
			suppressionTableValueText($1);
		}
	| WRITE E POINTVIRGULE
		{
			if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : WRITE E : E n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type == ENTREE_TYPECTE_BOOL)
			{
				ajoutTableGencode("ecritureBool",((structureID)pileStructure[nbPileStructure-1]->valeur)->nom,"","");
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type == ENTREE_TYPECTE_ENTIER)
			{
				ajoutTableGencode("ecriture",((structureID)pileStructure[nbPileStructure-1]->valeur)->nom,"","");
			}
			else
			{
				printf("Erreur : Yacc : WRITE E : E n'est ni un entier, ni un booleen.\n");
				erreurCompilation = 1;
			}
			
			suppressionTetePileStructure();
		}
	| IF E
		{
			if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : IF E THEN instr ELSE instr : E n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type == ENTREE_TYPECTE_BOOL)
			{				
				intTemp1 = nbLabelPourGenMips;
				nbLabelPourGenMips += 2;
				
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysLabelGenMips%d",intTemp1);
				
				ajoutTableGencode("if",((structureID)pileStructure[nbPileStructure-1]->valeur)->nom,bufferItoA,"");
				suppressionTetePileStructure();
				
				ajoutPileStructureIFTHENELSE(intTemp1,intTemp1+1);
			}
			else
			{
				printf("Erreur : Yacc : IF E THEN instr ELSE instr : E n'est pas un booleen.\n");
				erreurCompilation = 1;
			}
		}
		THEN instr 
		{
			if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_IFTHENELSE)
			{
				printf("Erreur : Yacc : IF E THEN instr ELSE instr : la tete de la pile structure n'est pas une reservation de labels.\n");
				erreurCompilation = 1;
			}
			else
			{				
				intTemp1 = ((structureIFTHENELSE)pileStructure[nbPileStructure-1]->valeur)->xfaux;
				intTemp2 = ((structureIFTHENELSE)pileStructure[nbPileStructure-1]->valeur)->xfin;			
				
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysLabelGenMips%d",intTemp2);
				ajoutTableGencode("jump",bufferItoA,"","");
				
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysLabelGenMips%d",intTemp1);
				ajoutTableGencode("label",bufferItoA,"","");
			}
		}
		ELSE instr
		{			
			if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_IFTHENELSE)
			{
				printf("Erreur : Yacc : IF E THEN instr ELSE instr : la tete de la pile structure n'est pas une reservation de labels.\n");
				erreurCompilation = 1;
			}
			else
			{				
				intTemp2 = ((structureIFTHENELSE)pileStructure[nbPileStructure-1]->valeur)->xfin;			
				
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysLabelGenMips%d",intTemp2);
				ajoutTableGencode("label",bufferItoA,"","");
			}
		}
	;
	
E 	: E op2		
		{			
			if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 op2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else
			{			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 op2 : E1 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					tableGencode[$2]->adresse2 = charTemp1;
					printf("\tajout infos à %d : %s %s, %s, %s\n",$2, tableGencode[$2]->commande,tableGencode[$2]->adresse1,tableGencode[$2]->adresse2,tableGencode[$2]->adresse3);					
				}
			}
		}
	| MOINS E 		
		{				
			if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> - E1 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> - E1 : E1 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{									
				//générer une varaible temporaire pour E
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteInt(bufferItoA, 0));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA); 
			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> - E1 : E1 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}			
				else
				{
					intTemp1 = ajoutTableGencode("moinsUnaire",bufferItoA,charTemp1,"");
					printf("\tajout (%d) : %s %s, %s, %s\n",intTemp1, tableGencode[intTemp1]->commande,tableGencode[intTemp1]->adresse1,tableGencode[intTemp1]->adresse2,tableGencode[intTemp1]->adresse3);
					
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_ENTIER);
					printf("\tajout pile %s\n",bufferItoA);
				}
			}
		}
	| PGAUCHE E PDROITE 		
		{
			//on fait rien -> recopie
		}
	| IDENTIFIANT
		{
			if(!existeMotClefHashTableHorsVide(tableValueText[$1]))
			{
				printf("Erreur : Yacc : E -> IDENTIFIANT : identifiant non declare (%s).\n",tableValueText[$1]);
				erreurCompilation = 1;
			}
			else if(consulteHashTable(tableValueText[$1]).valeur.type == ENTREE_TYPECTE_ENTIER)
			{
				ajoutPileStructureID(tableValueText[$1], ENTREE_TYPECTE_ENTIER);
				printf("\tajout pile %s\n",tableValueText[$1]);
			}
			else if(consulteHashTable(tableValueText[$1]).valeur.type == ENTREE_TYPECTE_BOOL)
			{
				ajoutPileStructureID(tableValueText[$1], ENTREE_TYPECTE_BOOL);
				printf("\tajout pile %s\n",tableValueText[$1]);		
			}
			else
			{
				printf("Erreur : Yacc : E -> IDENTIFIANT : identifiant n'est ni un entier ni un booleen (%s).\n",tableValueText[$1]);
				erreurCompilation = 1;
			}			
			
			suppressionTableValueText($1);
		}
	| ENTIER 		
		{
			//générer une varaible temporaire pour E
			bufferItoA = calloc (16, sizeof(char));
			sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
			ajoutEntreeHashTable(nouvelleEntreeCteInt(bufferItoA, 0));
			nbSysTemp++;
			printf("\t%s var temp\n",bufferItoA);
			
			charTemp1 = calloc (16, sizeof(char));
			sprintf(charTemp1,"%d",$1);
			intTemp1 = ajoutTableGencode("affectationVal",bufferItoA,charTemp1,"");
			printf("\tajout (%d) : %s %s, %s, %s\n",intTemp1,tableGencode[intTemp1]->commande,tableGencode[intTemp1]->adresse1,tableGencode[intTemp1]->adresse2,tableGencode[intTemp1]->adresse3);
			
			ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_ENTIER);
			printf("\tajout pile %s\n",bufferItoA);
		} 
	| NOT E		
		{
			if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> not E1 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_BOOL)
			{
				printf("Erreur : Yacc : E -> not E1 : E1 n'est pas un booleen.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour B
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteBool(bufferItoA, FAUX));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> not E1 : E1 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}			
				else
				{
					intTemp1 = ajoutTableGencode("logiqueNot",bufferItoA,charTemp1,"");
					printf("\tajout (%d) : %s %s, %s, %s\n",intTemp1, tableGencode[intTemp1]->commande,tableGencode[intTemp1]->adresse1,tableGencode[intTemp1]->adresse2,tableGencode[intTemp1]->adresse3);
					
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_BOOL);
					printf("\tajout pile %s\n",bufferItoA);
				}
			}
		}
	| BOOL		
		{
			//générer une varaible temporaire pour B
			bufferItoA = calloc (16, sizeof(char));
			sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
			ajoutEntreeHashTable(nouvelleEntreeCteBool(bufferItoA, FAUX));
			nbSysTemp++;
			printf("\t%s var temp\n",bufferItoA);
			
			charTemp1 = calloc (16, sizeof(char));
			sprintf(charTemp1,"%d",$1);
			intTemp1 = ajoutTableGencode("affectationVal",bufferItoA,charTemp1,"");
			printf("\tajout (%d) : %s %s, %s, %s\n",intTemp1,tableGencode[intTemp1]->commande,tableGencode[intTemp1]->adresse1,tableGencode[intTemp1]->adresse2,tableGencode[intTemp1]->adresse3);
			
			ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_BOOL);
			printf("\tajout pile %s\n",bufferItoA);
		}
	;
	
op2 : FOIS E		
		{	
			if(pileStructure[nbPileStructure-2] == NULL || pileStructure[nbPileStructure-2]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 * E2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-2]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 * E2 : E1 n'est pas un entier.\n");
				erreurCompilation = 1;
			} 
			else if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 * E2 : E2 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 * E2 : E2 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour E
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteInt(bufferItoA, 0));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
				
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 * E2 : E2 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					$$ = ajoutTableGencode("multiplication",bufferItoA,"",charTemp1);
					printf("\tajout (%d) : %s %s, %s, %s\n",$$,tableGencode[$$]->commande,tableGencode[$$]->adresse1,tableGencode[$$]->adresse2,tableGencode[$$]->adresse3);
					
					//on veut ajouter à la pile E (E -> E1 op2 E2). Mais E1 est au sommet de la pile et on en a besoin lors de la réduction.
					//on supprime donc E1 de la pile, on ajoute E, on ajoute à nouveau E1. Ainsi on conserve l'ordre
					intTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->type;
					charTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
					suppressionTetePileStructure();
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_ENTIER);
					printf("\tajout pile %s\n",bufferItoA);	
					ajoutPileStructureID(charTemp2, intTemp2);
					printf("\tajout pile %s\n",charTemp2);	
				}
			}
		}
	| PLUS E		
		{
			if(pileStructure[nbPileStructure-2] == NULL || pileStructure[nbPileStructure-2]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 + E2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-2]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 + E2 : E1 n'est pas un entier.\n");
				erreurCompilation = 1;
			} 
			else if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 + E2 : E2 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 + E2 : E2 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour E
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteInt(bufferItoA, 0));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
				
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 + E2 : E2 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					$$ = ajoutTableGencode("addition",bufferItoA,"",charTemp1);
					printf("\tajout : %s %s, %s, %s\n",tableGencode[$$]->commande,tableGencode[$$]->adresse1,tableGencode[$$]->adresse2,tableGencode[$$]->adresse3);
					
					//on veut ajouter à la pile E (E -> E1 op2 E2). Mais E1 est au sommet de la pile et on en a besoin lors de la réduction.
					//on supprime donc E1 de la pile, on ajoute E, on ajoute à nouveau E1. Ainsi on conserve l'ordre
					intTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->type;
					charTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
					suppressionTetePileStructure();
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_ENTIER);
					printf("\tajout pile %s\n",bufferItoA);	
					ajoutPileStructureID(charTemp2, intTemp2);
					printf("\tajout pile %s\n",charTemp2);	
				}
			}
		}
	| OR E		
		{
			if(pileStructure[nbPileStructure-2] == NULL || pileStructure[nbPileStructure-2]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 OR E2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-2]->valeur)->type != ENTREE_TYPECTE_BOOL)
			{
				printf("Erreur : Yacc : E -> E1 OR E2 : E1 n'est pas un booleen.\n");
				erreurCompilation = 1;
			} 
			else if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 OR E2 : E2 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_BOOL)
			{
				printf("Erreur : Yacc : E -> E1 OR E2 : E2 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour B
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteBool(bufferItoA, FAUX));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 OR E2 : E2 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					$$ = ajoutTableGencode("logiqueOr",bufferItoA,"",charTemp1);
					printf("\tajout (%d) : %s %s, %s, %s\n",$$,tableGencode[$$]->commande,tableGencode[$$]->adresse1,tableGencode[$$]->adresse2,tableGencode[$$]->adresse3);
					
					//on veut ajouter à la pile E (E -> E1 op2 E2). Mais E1 est au sommet de la pile et on en a besoin lors de la réduction.
					//on supprime donc E1 de la pile, on ajoute E, on ajoute à nouveau E1. Ainsi on conserve l'ordre
					intTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->type;
					charTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
					suppressionTetePileStructure();
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_BOOL);
					printf("\tajout pile %s\n",bufferItoA);	
					ajoutPileStructureID(charTemp2, intTemp2);
					printf("\tajout pile %s\n",charTemp2);	
				}
			}
		} 
	| AND E		
		{
			if(pileStructure[nbPileStructure-2] == NULL || pileStructure[nbPileStructure-2]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 AND E2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-2]->valeur)->type != ENTREE_TYPECTE_BOOL)
			{
				printf("Erreur : Yacc : E -> E1 AND E2 : E1 n'est pas un booleen.\n");
				erreurCompilation = 1;
			} 
			else if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 AND E2 : E2 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_BOOL)
			{
				printf("Erreur : Yacc : E -> E1 AND E2 : E2 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour B
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteBool(bufferItoA, FAUX));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 AND E2 : E2 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					$$ = ajoutTableGencode("logiqueAnd",bufferItoA,"",charTemp1);
					printf("\tajout (%d) : %s %s, %s, %s\n",$$,tableGencode[$$]->commande,tableGencode[$$]->adresse1,tableGencode[$$]->adresse2,tableGencode[$$]->adresse3);
					
					//on veut ajouter à la pile E (E -> E1 op2 E2). Mais E1 est au sommet de la pile et on en a besoin lors de la réduction.
					//on supprime donc E1 de la pile, on ajoute E, on ajoute à nouveau E1. Ainsi on conserve l'ordre
					intTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->type;
					charTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
					suppressionTetePileStructure();
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_BOOL);
					printf("\tajout pile %s\n",bufferItoA);	
					ajoutPileStructureID(charTemp2, intTemp2);
					printf("\tajout pile %s\n",charTemp2);	
				}
			}
		}
	| XOR E		
		{		
			if(pileStructure[nbPileStructure-2] == NULL || pileStructure[nbPileStructure-2]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 XOR E2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-2]->valeur)->type != ENTREE_TYPECTE_BOOL)
			{
				printf("Erreur : Yacc : E -> E1 XOR E2 : E1 n'est pas un booleen.\n");
				erreurCompilation = 1;
			} 
			else if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 XOR E2 : E2 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_BOOL)
			{
				printf("Erreur : Yacc : E -> E1 XOR E2 : E2 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour B
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteBool(bufferItoA, FAUX));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 XOR E2 : E2 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					$$ = ajoutTableGencode("logiqueXor",bufferItoA,"",charTemp1);
					printf("\tajout (%d) : %s %s, %s, %s\n",$$,tableGencode[$$]->commande,tableGencode[$$]->adresse1,tableGencode[$$]->adresse2,tableGencode[$$]->adresse3);
					
					//on veut ajouter à la pile E (E -> E1 op2 E2). Mais E1 est au sommet de la pile et on en a besoin lors de la réduction.
					//on supprime donc E1 de la pile, on ajoute E, on ajoute à nouveau E1. Ainsi on conserve l'ordre
					intTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->type;
					charTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
					suppressionTetePileStructure();
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_BOOL);
					printf("\tajout pile %s\n",bufferItoA);	
					ajoutPileStructureID(charTemp2, intTemp2);
					printf("\tajout pile %s\n",charTemp2);	
				}
			}
		}
	| EGAL E		
		{
			if(pileStructure[nbPileStructure-2] == NULL || pileStructure[nbPileStructure-2]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 EGAL E2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-2]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 EGAL E2 : E1 n'est pas un entier.\n");
				erreurCompilation = 1;
			} 
			else if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 EGAL E2 : E2 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 EGAL E2 : E2 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour B
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteBool(bufferItoA, FAUX));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 EGAL E2 : E2 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					$$ = ajoutTableGencode("logiqueEgal",bufferItoA,"",charTemp1);
					printf("\tajout : %s %s, %s, %s\n",tableGencode[$$]->commande,tableGencode[$$]->adresse1,tableGencode[$$]->adresse2,tableGencode[$$]->adresse3);
					
					//on veut ajouter à la pile E (E -> E1 op2 E2). Mais E1 est au sommet de la pile et on en a besoin lors de la réduction.
					//on supprime donc E1 de la pile, on ajoute E, on ajoute à nouveau E1. Ainsi on conserve l'ordre
					intTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->type;
					charTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
					suppressionTetePileStructure();
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_BOOL);
					printf("\tajout pile %s\n",bufferItoA);	
					ajoutPileStructureID(charTemp2, intTemp2);
					printf("\tajout pile %s\n",charTemp2);	
				}
			}
		}
	| DIFFERENT E		
		{
			if(pileStructure[nbPileStructure-2] == NULL || pileStructure[nbPileStructure-2]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 DIFFERENT E2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-2]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 DIFFERENT E2 : E1 n'est pas un entier.\n");
				erreurCompilation = 1;
			} 
			else if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 DIFFERENT E2 : E2 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 DIFFERENT E2 : E2 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour B
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteBool(bufferItoA, FAUX));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 DIFFERENT E2 : E2 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					$$ = ajoutTableGencode("logiqueDifferent",bufferItoA,"",charTemp1);
					printf("\tajout : %s %s, %s, %s\n",tableGencode[$$]->commande,tableGencode[$$]->adresse1,tableGencode[$$]->adresse2,tableGencode[$$]->adresse3);
					
					//on veut ajouter à la pile E (E -> E1 op2 E2). Mais E1 est au sommet de la pile et on en a besoin lors de la réduction.
					//on supprime donc E1 de la pile, on ajoute E, on ajoute à nouveau E1. Ainsi on conserve l'ordre
					intTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->type;
					charTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
					suppressionTetePileStructure();
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_BOOL);
					printf("\tajout pile %s\n",bufferItoA);	
					ajoutPileStructureID(charTemp2, intTemp2);
					printf("\tajout pile %s\n",charTemp2);	
				}
			}
		}
	| PPETITS E		
		{
			if(pileStructure[nbPileStructure-2] == NULL || pileStructure[nbPileStructure-2]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 PPETITS E2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-2]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 PPETITS E2 : E1 n'est pas un entier.\n");
				erreurCompilation = 1;
			} 
			else if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 PPETITS E2 : E2 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 PPETITS E2 : E2 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour B
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteBool(bufferItoA, FAUX));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 PPETITS E2 : E2 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					$$ = ajoutTableGencode("logiquePpetits",bufferItoA,"",charTemp1);
					printf("\tajout : %s %s, %s, %s\n",tableGencode[$$]->commande,tableGencode[$$]->adresse1,tableGencode[$$]->adresse2,tableGencode[$$]->adresse3);
					
					//on veut ajouter à la pile E (E -> E1 op2 E2). Mais E1 est au sommet de la pile et on en a besoin lors de la réduction.
					//on supprime donc E1 de la pile, on ajoute E, on ajoute à nouveau E1. Ainsi on conserve l'ordre
					intTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->type;
					charTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
					suppressionTetePileStructure();
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_BOOL);
					printf("\tajout pile %s\n",bufferItoA);	
					ajoutPileStructureID(charTemp2, intTemp2);
					printf("\tajout pile %s\n",charTemp2);	
				}
			}
		}
	| PPETIT E		
		{
			if(pileStructure[nbPileStructure-2] == NULL || pileStructure[nbPileStructure-2]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 PPETIT E2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-2]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 PPETIT E2 : E1 n'est pas un entier.\n");
				erreurCompilation = 1;
			} 
			else if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 PPETIT E2 : E2 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 PPETIT E2 : E2 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour B
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteBool(bufferItoA, FAUX));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 PPETIT E2 : E2 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					$$ = ajoutTableGencode("logiquePpetit",bufferItoA,"",charTemp1);
					printf("\tajout : %s %s, %s, %s\n",tableGencode[$$]->commande,tableGencode[$$]->adresse1,tableGencode[$$]->adresse2,tableGencode[$$]->adresse3);
					
					//on veut ajouter à la pile E (E -> E1 op2 E2). Mais E1 est au sommet de la pile et on en a besoin lors de la réduction.
					//on supprime donc E1 de la pile, on ajoute E, on ajoute à nouveau E1. Ainsi on conserve l'ordre
					intTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->type;
					charTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
					suppressionTetePileStructure();
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_BOOL);
					printf("\tajout pile %s\n",bufferItoA);	
					ajoutPileStructureID(charTemp2, intTemp2);
					printf("\tajout pile %s\n",charTemp2);	
				}
			}
		}
	| PGRAND E		
		{
			if(pileStructure[nbPileStructure-2] == NULL || pileStructure[nbPileStructure-2]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 PGRAND E2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-2]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 PGRAND E2 : E1 n'est pas un entier.\n");
				erreurCompilation = 1;
			} 
			else if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 PGRAND E2 : E2 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 PGRAND E2 : E2 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour E
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteBool(bufferItoA, FAUX));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 PGRAND E2 : E2 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					$$ = ajoutTableGencode("logiquePgrand",bufferItoA,"",charTemp1);
					printf("\tajout : %s %s, %s, %s\n",tableGencode[$$]->commande,tableGencode[$$]->adresse1,tableGencode[$$]->adresse2,tableGencode[$$]->adresse3);
					
					//on veut ajouter à la pile E (E -> E1 op2 E2). Mais E1 est au sommet de la pile et on en a besoin lors de la réduction.
					//on supprime donc E1 de la pile, on ajoute E, on ajoute à nouveau E1. Ainsi on conserve l'ordre
					intTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->type;
					charTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
					suppressionTetePileStructure();
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_BOOL);
					printf("\tajout pile %s\n",bufferItoA);	
					ajoutPileStructureID(charTemp2, intTemp2);
					printf("\tajout pile %s\n",charTemp2);	
				}
			}
		}
	| PGRANDS E		
		{
			if(pileStructure[nbPileStructure-2] == NULL || pileStructure[nbPileStructure-2]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 PGRANDS E2 : E1 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-2]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 PGRANDS E2 : E1 n'est pas un entier.\n");
				erreurCompilation = 1;
			} 
			else if(pileStructure[nbPileStructure-1] == NULL || pileStructure[nbPileStructure-1]->type != PILESTRUCTURE_TYPE_ID)
			{
				printf("Erreur : Yacc : E -> E1 PGRANDS E2 : E2 n'est pas un identifiant.\n");
				erreurCompilation = 1;
			}
			else if(((structureID)pileStructure[nbPileStructure-1]->valeur)->type != ENTREE_TYPECTE_ENTIER)
			{
				printf("Erreur : Yacc : E -> E1 PGRANDS E2 : E2 n'est pas un entier.\n");
				erreurCompilation = 1;
			}
			else
			{				
				//générer une varaible temporaire pour B
				bufferItoA = calloc (16, sizeof(char));
				sprintf(bufferItoA,"_SysTemp%d",nbSysTemp);
				ajoutEntreeHashTable(nouvelleEntreeCteBool(bufferItoA, FAUX));
				nbSysTemp++;
				printf("\t%s var temp\n",bufferItoA);
			
				charTemp1 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
				suppressionTetePileStructure();
				printf("\trécupération de %s dans la pileStructure\n",charTemp1);
				
				if(!existeMotClefHashTableHorsVide(charTemp1))
				{
					printf("Erreur : Yacc : E -> E1 PGRANDS E2 : E2 : identifiant non declare (%s).\n",charTemp1);
					erreurCompilation = 1;
				}
				else
				{
					$$ = ajoutTableGencode("logiquePgrands",bufferItoA,"",charTemp1);
					printf("\tajout : %s %s, %s, %s\n",tableGencode[$$]->commande,tableGencode[$$]->adresse1,tableGencode[$$]->adresse2,tableGencode[$$]->adresse3);
					
					//on veut ajouter à la pile E (E -> E1 op2 E2). Mais E1 est au sommet de la pile et on en a besoin lors de la réduction.
					//on supprime donc E1 de la pile, on ajoute E, on ajoute à nouveau E1. Ainsi on conserve l'ordre
					intTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->type;
					charTemp2 = ((structureID)pileStructure[nbPileStructure-1]->valeur)->nom;
					suppressionTetePileStructure();
					ajoutPileStructureID(bufferItoA, ENTREE_TYPECTE_BOOL);
					printf("\tajout pile %s\n",bufferItoA);	
					ajoutPileStructureID(charTemp2, intTemp2);
					printf("\tajout pile %s\n",charTemp2);	
				}
			}
		}
	;
	
%%

int yyerror(char * s)
{
	printf("\nErreur : %s\n\n", s);
	exit(-1);
}

int main (int argc, char ** argv)
{
	nbSysTemp = 0;

	if(argc != 3)
	{
		printf("\nUsage : %s <nom fichier en entrée> <nom fichier en sortie>\n\n",argv[0]);
		exit(-1);
	}	
	
	if ((yyin = fopen(argv[1], "r")) == NULL)
	{                  
		printf("\nErreur : impossible d'ouvrir le fichier %s\n\n", argv[1]);
		exit(-1);
	}
	
	if ((yyout = fopen(argv[2], "w+")) == NULL)
	{
		printf("Erreur : impossible de créer le fichier %s\n", argv[2]);
		exit(-1);          
	}
	
	initVariableADeclarer();
	initTableGencode();
	initHashTable();
	initPiles();
	initPourGestionPile();
	initPileStructure();
	erreurCompilation = 0;
	nbLabelPourGenMips = 0 ;
	
	printf("Debut analyse\n");
	yyparse();
	if(!hashTableVide())
	{
		sortieBloc();
	}
	printf("Fin analyse\n");
	
	//afficheTableGencode();
	
	if(erreurCompilation)
	{
		printf("Erreur : Yacc : il y a eu des erreurs à la compilation.\n");
		exit(-1);
	}
		
	printf("Debut génération mips\n");
	mipsGeneration(yyout);
	printf("Fin génération mips\n");
	
	fclose(yyin);	
	fclose(yyout);
	
	return 0;
}
